#include <iostream>
#include <string>

// 类声明前置 --- 类声明和实现在同一个文件，即在类声明时实现，所以是写在.h文件中的，不是.cpp文件
// 不同于内联方法的写法，内联方法用关键字inline指明

//class StructClass;

class StructClass
{
	// c++没有类中的静态代码块
	//static int staticVar;
	//static{
	//	staticVar = 10;
	//}

private:
	// 定义两个结构体数据类型
	typedef struct info { // 类内部的结构体，类似与普通变量
		std::string name;
		int age;
	};

	typedef struct infoName {
		int af;
	};


	// 结构体定义 = 结构体名可以写前面，也可以写后面
	typedef struct {
		int data[2];
		int length;
	}SqList;


	// 声明结构体*变量*时必须要初始化


public:
	void structureTestMain()
	{
		this->getStructureOfClass();
	}


	// 结构体
	// .和 -> 的区别，如结构变量时用. 指针指向时用 ->
	int structureTypeTest()
	{
		struct FishOil{ // 方法体内部的结构体作用域在本函数内
			std::string name; // 字符串对象
			int age;
			char sex;
		};
		return 0;
	}


	// 使用类中的结构体

	void getStructureOfClass()
	{
		struct info inf001 = { "",0 };
		inf001.name = "inf01";
		inf001.age = 10;
		std::cout << "类中的函数内部的结构体对象的地址：" << &inf001 << "\n";

		//Inm02* inm002 = NULL;
		//inm002->af = 20;
		//std::cout << inm002->af << "\n";
	}

	// 交换两个数
	void jiaoHuan()
	{
		int s = 1;
		int d = 2;
		std::cout << "交换前：值=" << s << " 地址=" << &s << std::endl;
		this->mySwap(&s, &d);
		std::cout << "mySwap交换后：值=" << s << " 地址=" << &s << std::endl;
		int* sw = &s;
		int* dw = &d;
		std::swap(sw, dw);
		std::cout << "std::swap交换后：值=" << s << " 地址=" << &s << 
			" dw=" << dw << " sw=" << sw << std::endl;
	}

	// 带地址的交换
	void mySwap(int* x, int* y) {
		int* tmp = nullptr;
		tmp = x;
		x = y;
		y = tmp;
	}

	// 按位异或
	void yihuo(int* x, int* y)
	{
		*x ^= *y;
		*y ^= *x; // ^=是按位异或赋值运算符。它用于将左操作数与右操作数进行按位异或运算，并将结果赋值给左操作数
		*x ^= *y;
	}


	// 定义一个抽象类/接口，没有类的实现，常用做基类
	class abstractClzz {
		// 纯虚函数，使 abstractClzz 成为抽象类
		virtual void doSomething() = 0;
	};

	// 定义继承自 abstractClzz 的类 clzzA
	class clzzA :public StructClass::abstractClzz {
	public:
		void doSomething() override {
			std::cout << "内部类和抽象类\n";
			std::cout << "class clzzA :public StructClass::abstractClzz\n";
			// 这里重载了父类中的纯虚函数，提供了具体的实现
			// 注意要使用 override 关键字确保正确地重载了基类的虚函数
			// 具体的实现内容可以根据需求编写
		}
	};




	////////////////// 构造函数和析构函数
	class stu {
	public:
		// 构造函数
		stu();
		stu(int a,int b)
		{
			this->a = a;
			this->b = b;
		}

		// 析构函数
		~stu()
		{

		}
		// 普通函数
		void tA();

	private:
		int64_t a;
		int64_t b;
	};


};




